#include <FU68xx_2.h>
#include <Myproject.h>

// 1.IO口初始化=>GPIOInit.C + GPIOInit.h
// 2.按键功能：KeyScan.c+KeyScan.h+ADCInit.c[按键模拟端口]
// 3.LED指示灯：LED.c + LED.h + Motorprotect.c[underprocess] ,要把ledInit()在main里面调用
// 4.定时器初始化：main.c+TimerInit.c+interrupt
// 5.添加渐变

void led1msBreath() // 放在1ms中断函数里面 TickCycle_1ms
{
    if (ledCt1.ledBreathONOFF == 1)
    {
        if (ledCt1.tempMode == 0) // 冷风态 RGB(0,0,255)
        {
            if (ledCt1.timeCnt < ledCt1.coldTime)
            {
                ledCt1.timeCnt++;
                if (ledCt1.timeCnt % (ledCt1.coldTime / 400) == 0)
                {
                    if (ledCt1.RDuty > 0) // 红色减少
                    {
                        ledCt1.RDuty--;
                    }
                }
                if (ledCt1.timeCnt % (ledCt1.coldTime / 256) == 0)
                {
                    if (ledCt1.BDuty < 255) // 蓝色增加
                    {
                        ledCt1.BDuty++;
                    }
                }
            }
            else
            {
                ledCt1.timeCnt = 0;
                ledCt1.tempMode = 1; // 切成热风模式
                KS.ChangeKeyFlg = 1;
            }
        }
        else
        {
            if (ledCt1.timeCnt < ledCt1.hotTime) // 热风状态  RGB(255,0,0)
            {
                ledCt1.timeCnt++;

                if (ledCt1.timeCnt % (ledCt1.hotTime / 400) == 0) // 改变这个255的值，就可以改变峰值到达时间，这样峰值有一个保持时间，255是最大值
                {
                    if (ledCt1.BDuty > 0) // 蓝光减少
                    {
                        ledCt1.BDuty--;
                    }
                }
                if (ledCt1.timeCnt % (ledCt1.hotTime / 256) == 0) // 改变这个255的值，就可以改变峰值到达时间，这样峰值有一个保持时间，255是最大值
                {
                    if (ledCt1.RDuty < 255) // 红光增加
                    {
                        ledCt1.RDuty++;
                    }
                }
            }
            else
            {
                ledCt1.timeCnt = 0;
                ledCt1.tempMode = 0; // 切成冷风模式
                KS.ChangeKeyFlg = 1;
            }
        }
    }
}

void ledDutyCtl()
{
    if (mcFocCtrl.ZeroLossFlag == 0)
    {
        if (ledCt1.ledCounter < ledCt1.ledCycle) // 周期,ledCt1.ledCycle = 255;
        {
            ledCt1.ledCounter++;
        }
        else
        {
            ledCt1.ledCounter = 0;
        }

        if (ledCt1.ledCounter < ledCt1.RDuty) // 红灯占空比
        {
            R(ON);
        }
        else
        {
            R(OFF);
        }

        if (ledCt1.ledCounter < ledCt1.GDuty) // 绿灯占空比
        {
            G(ON);
        }
        else
        {
            G(OFF);
        }

        if (ledCt1.ledCounter < ledCt1.BDuty) // 蓝灯占空比
        {
            B(ON);
        }
        else
        {
            B(OFF);
        }
    }
    else
    {
        LED_OFF;
    }

    // if (((mcState == mcRun) && (MCCtrl.FlagONOFF == 1) && (mcFocCtrl.powLossFlag == 0)) || (mcFaultSource != FaultNoSource))
    // {
    //     if (ledCt1.ledCounter < ledCt1.ledCycle) // 周期,ledCt1.ledCycle = 255;
    //     {
    //         ledCt1.ledCounter++;
    //     }
    //     else
    //     {
    //         ledCt1.ledCounter = 0;
    //     }

    //     if (ledCt1.ledCounter < ledCt1.RDuty) // 红灯占空比
    //     {
    //         R(ON);
    //     }
    //     else
    //     {
    //         R(OFF);
    //     }

    //     if (ledCt1.ledCounter < ledCt1.GDuty) // 绿灯占空比
    //     {
    //         G(ON);
    //     }
    //     else
    //     {
    //         G(OFF);
    //     }

    //     if (ledCt1.ledCounter < ledCt1.BDuty) // 蓝灯占空比
    //     {
    //         B(ON);
    //     }
    //     else
    //     {
    //         B(OFF);
    //     }
    // }
    // else
    // {
    //     LED_OFF;
    // }
}

void tempSet(void) // 简单丢波，波动预计会大一些，放在TIM2时间中断里面
{
    if ((User.TPCtrlDealy < 4800) && (mcState == mcRun) && (mcFocCtrl.SpeedFlt > 12000) && (User.ScrOnAngleTime != Temperature_Off) && (mcFocCtrl.Powerlpf > 1000) && (User.overHeatFlag == 0) && (User.HeatFlag == 0))
    {
        User.ScrOnTime++;
        if (User.ScrOnTime <= User.ScrOnPeriod)
        {
            if ((User.ScrOnTime <= User.ScrOnAngleTimeDatum))
            {
                GP01 = 0; // 打开发热丝
            }
            else
            {
                GP01 = 1; // 关闭发热丝
            }
        }

        if (User.ScrOnTime >= User.ScrOnPeriod)
        {
            User.ScrOnTime = 0;
        }
    }
    else
    {
        GP01 = 1; // 关闭发热丝
    }
}

void tempSet1(void) // 间隔丢波，波动预计小一点,放在TIM2时间中断里面
{
    if ((User.TPCtrlDealy < 4800) && (mcState == mcRun) && (mcFocCtrl.SpeedFlt > 12000) && (User.overHeatFlag == 0) && (User.HeatFlag == 0))
    {
        User.ScrOnTime++;
        if (User.ScrOnTime <= User.ScrOnPeriod)
        {
            if (User.ScrOnAngleTimeDatum == User.ScrOnPeriod)
            {
                User.tempOnFlag = 1;
            }
            else if (User.ScrOnAngleTimeDatum * 2 >= User.ScrOnPeriod)
            {
                if ((User.ScrOnTime % User.tempCycle == 0) && (User.ScrOnTime <= User.tempCycle * User.tempDt)) // 开多关少
                {
                    User.tempOnFlag = 0; // 关发热丝
                }
                else
                {
                    User.tempOnFlag = 1; // 开发热丝
                }
            }
            else
            {
                if ((User.ScrOnTime % User.tempCycle == 0) && (User.ScrOnTime <= User.tempCycle * User.tempDt)) // 开少关多
                {
                    User.tempOnFlag = 1; // 开发热丝
                }
                else
                {
                    User.tempOnFlag = 0; // 关发热丝
                }
            }

            if ((User.ScrOnAngleTime != Temperature_Off) && (mcFocCtrl.Powerlpf > 1000) && (User.tempOnFlag == 1))
            {
                GP01 = 0; // 打开发热丝
            }
            else
            {
                GP01 = 1; // 关闭发热丝
            }
        }
        if (User.ScrOnTime >= User.ScrOnPeriod)
        {
            User.ScrOnTime = 0;
        }
    }
    else
    {
        GP01 = 1; // 关闭发热丝
    }
}

/// @brief 关闭发热丝->放1ms中断里面，main
// void tempOff() // 过零后，延迟8ms给发热丝开关信号，信号维持6ms,在1ms中断里面延迟关闭发热丝.
// {
//     if (User.tempCnt < 8)
//     {
//         User.tempCnt++;
//     }
//     else if (User.tempCnt == 8)
//     {
//         GP01 = 1; // 关闭发热丝
//         User.tempCnt++;
//     }
//     else
//     {
//         User.tempCnt = 10;
//     }
// }

// void powerLoss() // 断电判断，断电的时候，母线电压可能会反冲，但是反冲后会一直下降，150ms会完成掉电压，掉到110V以下
// {
//     if (mcFocCtrl.powLossFlag == 0)
//     {
//         if (mcFocCtrl.mcDcbusFltDuty < 50)
//         {
//             if (mcFocCtrl.mcDcbusFltDuty == 0)
//             {
//                 mcFocCtrl.mcDcbusFlt1st1 = mcFocCtrl.mcDcbusFlt; // 采集1s的第一个点
//                 mcFocCtrl.SpeedFlt1st = mcFocCtrl.SpeedFlt;      // 采集1s的第一个点
//             }
//             if (mcFocCtrl.mcDcbusFltDuty % 2 == 0)
//             {
//                 if ((mcFocCtrl.mcDcbusFltPre1 > mcFocCtrl.mcDcbusFlt) && (mcFocCtrl.mcDcbusFlt < UNDER_PROTECT_VALUE))
//                 {
//                     mcFocCtrl.mcDcbusFltCnt1++;
//                 }
//                 mcFocCtrl.mcDcbusFltPre1 = mcFocCtrl.mcDcbusFlt; // 每2ms采一个点
//             }
//             mcFocCtrl.mcDcbusFltDuty++;
//         }
//         else
//         {
//             // u8ToDec(mcFocCtrl.powLossFlag);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFltCnt1);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFlt1st1);
//             // UART_SendData(0x7C);
//             // u16ToDec((mcFocCtrl.mcDcbusFlt));
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.SpeedFlt1st);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.SpeedFlt);
//             // （1）掉电的时候mcFocCtrl.mcDcbusFltCnt1会比较大 （2）mcFocCtrl.mcDcbusFlt1st1会大mcFocCtrl.mcDcbusFlt比较多
//             if ((mcFocCtrl.mcDcbusFltCnt1 > 20) && (mcFocCtrl.mcDcbusFlt1st1 > (mcFocCtrl.mcDcbusFlt + 500)))
//             {
//                 mcFocCtrl.powLossFlag = 1; // 电压丢失了已经
//                 mcFocCtrl.mcDcbusFltCnt2 = 0;
//                 mcFocCtrl.mcDcbusFltCnt3 = 0;
//                 LED_OFF;
//                 RGB(0, 0, 0);
//                 User.overHeatFlag = 0;
//                 mcFocCtrl.mcDcbusFltCnt1 = 0;
//             }
//             mcFocCtrl.mcDcbusFltCnt1 = 0;
//             mcFocCtrl.mcDcbusFltDuty = 0;
//         }
//     }

//     if (mcFocCtrl.powLossFlag == 1)
//     {
//         if (mcFocCtrl.mcDcbusFltDuty < 100)
//         {
//             if (mcFocCtrl.mcDcbusFlt > UNDER_RECOVER_VALUE)
//             {
//                 mcFocCtrl.mcDcbusFltCnt3++;
//             }
//         }
//         else
//         {
//             // u8ToDec(mcFocCtrl.powLossFlag);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFltCnt2);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFltCnt3);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFlt1st2);
//             // UART_SendData(0x7C);
//             // u16ToDec(mcFocCtrl.mcDcbusFlt);
//             // （1）掉电的时候mcFocCtrl.mcDcbusFltCnt2会比较大 （2）mcFocCtrl.mcDcbusFlt1st2会大mcFocCtrl.mcDcbusFlt比较多
//             if (mcFocCtrl.mcDcbusFltCnt3 > 95)
//             {
//                 mcFocCtrl.powLossFlag = 0; // 电压恢复了
//                 mcFocCtrl.mcDcbusFltCnt3 = 0;
//             }
//             mcFocCtrl.mcDcbusFltCnt3 = 0;
//             mcFocCtrl.mcDcbusFltDuty = 0;
//         }
//     }
// }

/// @brief 母线电压平均值 ,放到1ms中断里面 main  获得 User.AverageVoltageValue
void DCBusAvg() // 每40ms采集到一个平均电压值,2个交流电周期
{
    if (mcFocCtrl.mcDcbusFlt2cnt < 40)
    {
        mcFocCtrl.mcDcbusFlt2cnt++;
        mcFocCtrl.mcDcbusFlt1 = ADC2_DR << 3;
        mcFocCtrl.mcDcbusFlt2Sum += mcFocCtrl.mcDcbusFlt1;
    }
    else
    {
        mcFocCtrl.mcDcbusFlt2cnt = 0;
        User.ScrOnAngleRatioK = (float)(mcFocCtrl.mcDcbusFlt2Sum / 40.0);
        User.AverageVoltageValue = User.ScrOnAngleRatioK * 0.01 + 21.0;
        mcFocCtrl.mcDcbusFlt2Sum = 0;

        if ((ABS(User.AverageVoltageValuePre - User.AverageVoltageValue) > 2.0) || (User.VoltageScrOnAngleChangeFlag == 1))
        {
            User.VoltageScrOnAngleChangeFlag = 0;
            User.ScrOnAngleRatioK1 = (float)User.ScrOnAngleTime * (113.0 * 113.0) / (User.AverageVoltageValue * User.AverageVoltageValue);
            User.VoltageScrOnAngleTimeAvg = (User.ScrOnAngleRatioK1 + 0.5) * 10 / 10;
            tempCal(User.VoltageScrOnAngleTimeAvg);
            User.AverageVoltageValuePre = User.AverageVoltageValue;
        }
    }
}

// // 电压平衡,放到1ms中断里面 main  获得User.VoltageScrOnAngleTimeAvg 基于User.ScrOnAngleTime
// void voltageTempBalance()
// {
//     if (User.AverageVoltageValue >= 200) // 大于AC 250V
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 10;
//     }
//     else if (User.AverageVoltageValue >= 190) // 大于AC 250V
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 9;
//     }
//     else if (User.AverageVoltageValue >= 183) // 大于AC 250V
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 8;
//     }
//     else if (User.AverageVoltageValue >= 175) // 大于AC 250V
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 7;
//     }
//     else if (User.AverageVoltageValue >= 169) // 大于AC 250V
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 6;
//     }
//     else if (User.AverageVoltageValue >= 163)
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 5;
//     }
//     else if (User.AverageVoltageValue >= 158)
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 4;
//     }
//     else if (User.AverageVoltageValue >= 150)
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 3;
//     }
//     else if (User.AverageVoltageValue >= 145)
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 2;
//     }
//     else if (User.AverageVoltageValue >= 140)
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime - 1;
//     }
//     else
//     {
//         User.VoltageScrOnAngleTime = User.ScrOnAngleTime;
//     }

//     if (User.VoltageScrOnAngleTime < 3) // 冷风的情况
//     {
//         User.VoltageScrOnAngleTime = 3;
//     }

//     if (User.VoltageScrOnAngleTimeCnt < 30) // 40*30=1200 每1.2s进行一次电压调节，总共2*30=60个交流电周期
//     {
//         User.VoltageScrOnAngleTimeCnt++;
//         User.VoltageScrOnAngleTimeSum += User.VoltageScrOnAngleTime;
//     }
//     else
//     {
//         User.VoltageScrOnAngleTimeAvgOld = User.VoltageScrOnAngleTimeAvg;
//         User.VoltageScrOnAngleTimeAvg = User.VoltageScrOnAngleTimeSum / 30;
//         User.VoltageScrOnAngleTimeSum = 0;
//         User.VoltageScrOnAngleTimeCnt = 0;
//         if ((User.VoltageScrOnAngleTimeAvgOld != User.VoltageScrOnAngleTimeAvg) || (User.ScrOnAngleChange != 0)) // 电压有变化才重新赋值，避免重置NTC调节结果
//         {
//             User.ScrOnAngleTime_V = User.VoltageScrOnAngleTimeAvg;

//             if (User.ScrOnAngleTime_V > 15)
//             {
//                 User.ScrOnAngleTime_L = User.ScrOnAngleTime_V - 6;
//             }
//             else if (User.ScrOnAngleTime_V > 10)
//             {
//                 User.ScrOnAngleTime_L = User.ScrOnAngleTime_V - 5;
//             }
//             else if (User.ScrOnAngleTime_V > 6)
//             {
//                 User.ScrOnAngleTime_L = User.ScrOnAngleTime_V - 4;
//             }
//             else
//             {
//                 User.ScrOnAngleTime_L = 2;
//             }

//             // if (User.ntcFaultFlag)
//             // {
//             //     User.ScrOnAngleTimeDatum = User.VoltageScrOnAngleTimeAvg; // NTC故障的时候电压恒功率
//             // }
//             // else
//             // {
//             //     if (User.ScrOnAngleTimeDatum > User.VoltageScrOnAngleTimeAvg) // NTC没有故障的时候，当前功率设定大于电压恒功率计算值的时候，以小的为上限
//             //     {
//             //         User.ScrOnAngleTimeDatum = User.VoltageScrOnAngleTimeAvg;
//             //     }
//             // }
//             User.ScrOnAngleTimeDatum = ScrOnAngleTable[User.VoltageScrOnAngleTimeAvg][0];
//             User.ScrOnPeriod = ScrOnAngleTable[User.VoltageScrOnAngleTimeAvg][1];
//             User.ScrOnAngleChange = 0;
//         }
//     }
// }

// void NTCTempAdjust()
// {
//     if ((User.ScrOnAngleTime != Temperature_Off) && (!User.ntcFaultFlag))
//     {
//         if (User.etCnt < 100) // 1s调节一次温度【温度平衡时间大约需要15s】
//         {
//             User.etCnt++;
//         }
//         else if (User.etCnt < 150) // 15000~16000 之间的1s内进行采样
//         {
//             // User.et_before = User.et_now;
//             User.et_now = User.Temperature - User.targetTempAD; // 为正说明温度没有达到
//             User.et_sum += User.et_now;                         // 累计偏差
//             User.etCnt++;
//         }
//         else
//         {
//             User.et_avg = User.et_sum / 50; // 偏差平均值

//             if (User.ScrOnAngleTimeDatum > User.ScrOnAngleTime_L && User.et_avg < -User.targetTempAD * 10 / 100) // 调整范围在10%的温度AD值，负得越多，温度越高
//             {
//                 User.ScrOnAngleTimeDatum--;
//             }
//             else if (User.ScrOnAngleTimeDatum < User.ScrOnAngleTime_V && User.et_avg > User.targetTempAD * 10 / 100)
//             {
//                 User.ScrOnAngleTimeDatum++;
//             }
//             User.ScrOnAngleTimeDatum = ScrOnAngleTable[User.ScrOnAngleTimeDatum][0];
//             User.ScrOnPeriod = ScrOnAngleTable[User.ScrOnAngleTimeDatum][1];
//             User.etCnt = 0;
//             User.et_sum = 0;
//         }
//     }
// }

/// @brief 过热保护函数->放1ms中断里面，main
void overHeat()
{
    // User.Temperature <50 NTC可能短路了，User.Temperature >30000 NTC可能开路了，这两种情况判断为NTC失效
    if ((!User.ntcFaultFlag) && (User.Temperature > 50) && (User.Temperature < 30000) && (User.TPCtrlDealy == 0))
    {
        User.TemperatureSum += User.Temperature;
        if (++User.tCnt >= 10) // 每128ms检测一次温度平均值
        {
            User.tCnt = 0;
            User.TemperatureAverage = User.TemperatureSum / 10;
            User.TemperatureSum = 0;
            if (User.TemperatureAverage <= 800)
            {
                if (User.overtCnt < 10) // 过热后20*128=2560ms开始保护
                    User.overtCnt++;
                else
                    User.overHeatFlag = 1; // 过热
            }
            else if (User.TemperatureAverage > 2000)
            {
                if (User.overtCnt > 0)
                    User.overtCnt--;
                else
                    User.overHeatFlag = 0; // 没有过热
            }

            if (User.overHeatFlag == 1)
            {
                if (User.overedCnt < 20) // 128*120=15360ms
                {
                    User.overedCnt++;
                }
                else
                {
                    MCCtrl.FlagONOFF = 0;
                    MCCtrl.TargetValue = 0;
                    User.ScrOnAngleTime = Temperature_Off;
                    User.TPCtrlDealy = 5000;
                    mcFaultSource = FaultOverHeat;
                }
            }
            else
            {
                if (User.overedCnt > 0)
                {
                    User.overedCnt--;
                }
            }
        }
    }
}

// void NTCFaultTest()
// {
//     if ((User.Temperature < 50) || (User.Temperature > 30000)) // NTC有效检测
//     {
//         if (User.ntcFaultCnt < 1000)
//         {
//             User.ntcFaultCnt++;
//         }
//         else if (User.ntcFaultChange == 0)
//         {
//             User.ntcFaultChange = 1;
//             User.ntcFaultFlag = 1; // NTC故障
//             KS.ChangeKeyFlg = 1;
//         }
//     }
//     else
//     {
//         if (User.ntcFaultCnt > 0)
//         {
//             User.ntcFaultCnt--;
//         }
//         else
//         {
//             User.ntcFaultFlag = 0; // NTC正常
//             User.ntcFaultChange = 0;
//         }
//     }
// }

void faultLed()
{
    if (mcFaultSource != FaultNoSource)
    {
        if (mcFocCtrl.faultLedCnt < 2000)
        {
            mcFocCtrl.faultLedCnt++;
        }
        else
        {
            switch (mcFaultSource)
            {
            case FaultLossPhase:
                RGB(255, 0, 0);
                break;
            case FaultHardOVCurrent:
                RGB(0, 255, 0);
                break;
            case FaultSoftOVCurrent:
                RGB(0, 0, 255);
                break;
            case FaultOverVoltage:
                RGB(255, 20, 0);
                break;
            case FaultOverHeat:
                RGB_ONOFF(255, 0, 0);
                break;
            case FaultUnderVoltage:
                RGB_ONOFF(0, 255, 0);
                break;
            case FaultStart:
                RGB_ONOFF(0, 0, 255);
                break;
            case FaultStall:
                RGB_ONOFF(255, 20, 0);
                break;
            case FaultOverPower:
                RGB_ONOFF(0, 255, 255);
                break;
            default:
                break;
            }
        }
    }
    else
    {
        mcFocCtrl.faultLedCnt = 0;
    }
}

void zeroLoss(void)
{
    if (mcFocCtrl.ZeroLossFlag == 0)
    {
        if (mcFocCtrl.ZeroCnt < 52)
        {
            mcFocCtrl.ZeroCnt++;
        }
        else
        {
            mcFocCtrl.ZeroLossFlag = 20; // 过零丢失
        }
    }
}
